home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 110_01 / yam7.c < prev    next >
Text File  |  1984-03-02  |  12KB  |  571 lines
  1. /*
  2. >>:yam7.c 9-8-81
  3.  * File open and close stuff
  4.  * This file assumes operation on a CP/M system
  5.  */
  6. #include "yam.h"
  7.  
  8.  
  9. struct fcb {    /* CP/M Version 2 fcb AS SEEN BY THE USER */
  10.     char    dr;        /* drive number */
  11.     char    fname[8];    /* fname[1] used by TAG2 */
  12.     char    ftype[3];    /* corresponds to extension in rt-11 */
  13.     char    ex;        /* file extent normally 0 */
  14.     char s1;        /* reserved for bdos's benefit */
  15.     char s2;        /* likewise, =0 on call to open,make,search */
  16.     char    rc;        /* record count for extent[ex]  0...128 */
  17.     char dmap[16];
  18.     char cr;        /* current record, initialized to 0 by usr */
  19.     unsigned recn;        /* highest record number */
  20.     char recovf;        /* overflow of above */
  21. };
  22.  
  23. #define CONST 2            /* bios console char ready */
  24. #define CONIN 3            /* bios cons char input */
  25. #define CONOUT 4        /* bios cons char output */
  26. #define SRCH 17         /*bdos search for file pattern*/
  27. #define SRCHNXT 18        /* search for next occurrence */
  28. #define SETDMA 26        /* set address for read, write, etc. */
  29. #define SETATTRIB 30        /* update file attributes */
  30. #define SETGETUSER 32        /* set or get user number */
  31. #define COMPFILSIZ 35        /* compute file size into recn and recovf */
  32. #define UFNSIZE 15        /* a:foobar12.urk\0 is 15 chars */
  33.  
  34. openrx(name)
  35. char *name;
  36. {
  37.  
  38. #ifdef RESTRICTED
  39.     char *s;
  40.     if(s=cisubstr(name, ".com"))    /* upload .com files as .obj */
  41.         strcpy(s, ".OBJ");
  42.     if(cisubstr(name, "$$$"))
  43.         return ERROR;        /* don't allow upload of $$$.sub */
  44. #endif
  45. #ifdef LOGFILE
  46.     logfile(name, 'r');        /* record file xmsn */
  47. #endif
  48.     unspace(name);
  49.     lprintf("'%s' ", name);        /* show the name right away */
  50.     if(!Creamfile && fopen(name, fout) != ERROR) {
  51.         fclose(fout);
  52.         printf("Exists ", name);
  53. #ifdef XMODEM
  54.         return ERROR;
  55. #else
  56.         printf("Replace it (y/n)??");
  57.         if(tolower(getchar())!= 'y')
  58.             return ERROR;
  59. #endif
  60.     }
  61.     if(fcreat(name, fout)==ERROR){
  62.         printf("Can't create %s\n", name);
  63.         return ERROR;
  64.     }
  65.     Rfile= TRUE;
  66.     strcpy(Rname, name);
  67.     Dumping= !Squelch;
  68.     lprintf("Created%s\n", Dumping? "" : " recording OFF");
  69.     return OK;
  70. }
  71.  
  72. closerx(pad)
  73. {
  74.     if(Rfile) {
  75.         if(!Quiet)
  76.             lpstat("Closing %s", Rname);
  77. #ifdef BDSC
  78.         if(pad)
  79.             do
  80.                 putc(CPMEOF, fout);
  81.                 while(fout._nleft % SECSIZ);
  82. #endif
  83.         fflush(fout);
  84.         fclose(fout);
  85.         Rfile=FALSE;
  86.     }
  87. }
  88.  
  89. opentx(name)
  90. char *name;
  91. {
  92.     struct fcb *fp, *fcbaddr();
  93.     lprintf("'%s' ", name);
  94. #ifdef LOGFILE
  95.     logfile(name, 's');        /* record file xmsn */
  96. #endif
  97.     unspace(name);
  98.     if(fopen(name, fin)==ERROR){
  99.         printf("Can't open %s\n", name);
  100.         return ERROR;
  101.     }
  102. #ifdef RESTRICTED
  103.     if(cisubstr(name, ".bad")
  104.      || (fp=fcbaddr(fin._fd))==ERROR
  105.      || (fp->fname[1] & 0200)
  106.      ) {
  107.          fclose(fin); printf("\n'%s' Not for Distribution\n", name);
  108.         return ERROR;
  109.     }
  110. #endif
  111.     Tfile= TRUE;
  112.     strcpy(Tname, name);
  113.     lprintf("Open\n");
  114.     return OK;
  115. }
  116.  
  117. closetx()
  118. {
  119.     if(Tfile) {
  120.         fclose(fin);
  121.         if(!Quiet)
  122.             lpstat("%s closed", Tname);
  123.         Tfile=FALSE;
  124.     }
  125. }
  126. /* search the phone file for name */
  127. getphone(name, buffer)
  128. char *name, *buffer;
  129. {
  130.     closetx();
  131.  
  132.     if(fopen(PHONES, fin)==ERROR) {
  133.         printf("Cannot open %s\n", PHONES);
  134.         return ERROR;
  135.     } else {
  136.         while(fgets(buffer, fin))
  137.             if(cmdeq(buffer, name)) {
  138.                 fclose(fin);
  139.                 return OK;
  140.             }
  141.     }
  142.     printf("Can't find data for %s\n", name);
  143.     fclose(fin);
  144.     return ERROR;
  145. }
  146.  
  147. /* channge default disk and optionally, user number */
  148. chdir(p)
  149. char *p;
  150. {
  151.     unsigned newuser;
  152.  
  153.     newuser=user; *p=toupper(*p);
  154.     if(index(*p, DISKS)) {
  155.         defdisk= *p - 'A';
  156.         bdos(14, defdisk);
  157. #ifdef CDOS
  158.         return;
  159. #else
  160.         if(!isdigit(p[1]))
  161.             return;
  162.         if((newuser=atoi(p+1)) <= MAXUSER) {
  163.             bdos(SETGETUSER, newuser);
  164.             user=newuser;
  165.             return;
  166.         }
  167. #endif
  168.     }
  169.     printf("Disk %c and/or User %d Illegal\n", *p, newuser);
  170. }
  171.  
  172. /* fetch default disk and user number */
  173. initdd()
  174. {
  175.     Secpblk=SECPBLK;
  176.     defdisk= bdos(25,0);
  177. #ifdef CDOS
  178.     user=0;
  179. #else
  180.     user=bdos(SETGETUSER, 0377);
  181. #endif
  182. }
  183.  
  184. /*
  185.  * Z19 gets to use it's 25th line. pstat starts at 48th char
  186.  * note that a call to lpstat will erase what pstat displays
  187.  */
  188. /*VARARGS*/
  189. pstat(a,b,c)
  190. char *a, *b, *c;
  191. {
  192. #ifdef Z19
  193.     lprintf("\033x1\033j\033Y8P");
  194. #endif
  195.     lprintf(a,b,c);
  196. #ifdef Z19
  197.     lprintf("\033K\033k");
  198. #else
  199.     lprintf("\n");
  200. #endif
  201. }
  202.  
  203. /*
  204.  * Z19 gets to use it's 25th line. lpstat starts at col 1
  205.  * Rest of line is erased
  206.  */
  207. /*VARARGS*/
  208. lpstat(a,b,c)
  209. char *a, *b, *c;
  210. {
  211. #ifdef Z19
  212.     lprintf("\033x1\033j\033Y8 ");
  213. #endif
  214.     lprintf(a,b,c);
  215. #ifdef Z19
  216.     lprintf("\033K\033k");
  217. #else
  218.     lprintf("\n");
  219. #endif
  220. }
  221. char getcty()
  222. {
  223.     return bios(CONIN,0);
  224. }
  225. char putcty(c)
  226. char c;
  227. {
  228.     bios(CONOUT, c);
  229.     if(bios(CONST,0)) {
  230.         if((c=bios(CONIN,0))==XOFF)
  231.             bios(CONIN,0);
  232.         else
  233.             return c;
  234.     }
  235.     return FALSE;
  236. }
  237.  
  238. dolist(argc, argp)
  239. char **argp;
  240. {
  241.     int listfile();
  242.  
  243. #ifdef XMODEM
  244.  
  245.     printf("^S pauses, ^K skips to next file, ^X terminates\n");
  246.  
  247. #endif
  248.  
  249.     expand(listfile, argc, argp);
  250. }
  251.  
  252. listfile(name)
  253. char *name;
  254. {
  255.     int c;
  256.  
  257. #ifdef XMODEM
  258.     printf("\nListing '%s'\n\022", name);
  259. #endif
  260.     closetx();
  261.     if(opentx(name)==ERROR)
  262.         return ERROR;
  263.     else {
  264.         while((c=getc(fin))!=EOF && c != CPMEOF) {
  265.             if( !(c=putcty(c)))
  266.                 continue;
  267.             if(c==003 || c==CAN || c==013)
  268.                 break;
  269.         }
  270.         closetx();
  271. #ifdef XMODEM
  272.         sendline(024);    /* squelch in case user downloading */
  273. #endif        
  274.     }
  275.     /* cancel rest of files if ^C ^X */
  276.     if(c==003 || c==CAN)
  277.         return ERROR;
  278.     else
  279.         return OK;
  280. }
  281.  
  282. /* fill buf with count chars padding with ^Z for CPM */
  283. filbuf(buf, count)
  284. char *buf;
  285. {
  286.     register c, m;
  287.     m=count;
  288.     while((c=getc(fin))!=EOF) {
  289.         *buf++ =c;
  290.         if(--m == 0)
  291.             break;
  292.     }
  293.     if(m==count)
  294.         return 0;
  295.     else
  296.         while(--m>=0)
  297.             *buf++ = 032;
  298.     return count;
  299. }
  300.  
  301. dodir(argc, argp)
  302. char **argp;
  303. {
  304. /*    printf("Directory\n");*/
  305.     int pdirent();
  306.     cfast=0;        /* counter for 4 across format */
  307.     expand(pdirent, argc, argp);
  308. }
  309. pdirent(name)
  310. {
  311.     printf("%-14s%c", name, (++cfast&03)?' ':'\n');
  312. }
  313. #ifndef CDOS
  314. /* docomp does a directory listing showing sectors for each matched file
  315.  * and computes total transmission time of matched files in batch mode
  316.  * time is sum of:
  317.  *     number of files * open/close time (assumed 5 seconds)
  318.  *    time to xmit and ACK each sector assuming no path delay or error
  319.  *    disk i/o time at each end, not dependent on baud rate
  320.  */
  321. docomp(argc,argp)
  322. char **argp;
  323. {
  324.     unsigned compsecs();
  325.     unsigned spm;    /* sectors per minute-baud */
  326.     unsigned dminutes;    /* tenths of minutes */
  327.     cfast=Numsecs=Numblks=0;
  328. /*    printf("Directory\n");*/
  329.     expand(compsecs, argc, argp);
  330.  
  331.     spm= Baudrate/23;    /* (Baudrate*60)/(10 bits each char * 136 chars) */
  332.     dminutes= (Numfiles/2)+((10*(Numfiles+Numsecs))/spm)+(Numsecs/25);
  333.     printf("\n%u Files %u Blocks %u K\n",
  334.       Numfiles, Numblks, (Numblks*(Secpblk/8)));
  335.     printf("%u Sectors %u.%u Minutes Xmsn Time at %u Baud\n",
  336.       Numsecs, dminutes/10, dminutes%10, Baudrate);
  337.  
  338. }
  339. /* add file length (in CP/M 128 byte records) to Numsecs */
  340. unsigned compsecs(ufn)
  341. char *ufn;
  342. {
  343.     struct fcb fstat;
  344.     printf("%-14s", ufn);
  345.     unspace(ufn);
  346.     setfcb( &fstat, ufn);
  347.     bdos(COMPFILSIZ, &fstat);
  348.     Numsecs += fstat.recn;
  349.     Numblks += (fstat.recn+Secpblk)/Secpblk;
  350.     printf("%4u%c",fstat.recn, (++cfast&03)?' ':'\n');
  351. }
  352. #endif
  353.  
  354. expand(fnx, argc, argp)
  355. int (*fnx)();
  356. char **argp;
  357. {
  358.     char name[PATHLEN], *s;
  359.     Numfiles=0;
  360.  
  361.     if(argc<=0)
  362.         return e1xpand(fnx, "*.*");
  363.     else
  364.         while(--argc>=0) {
  365.             /* change b: to b:*.*     */
  366.             strcpy(name, *argp++);
  367.             if((s=index(':', name)) && *++s == 0)
  368.                 strcpy(s, "*.*");
  369.             if(e1xpand(fnx, name)==ERROR)
  370.                 return ERROR;
  371.         }
  372. }
  373.  
  374. /*
  375.  * e1xpand expands ambiguous pathname afnp
  376.  * calling fnx for each.
  377.  * Modified from: Parameter list builder by Richard Greenlaw
  378.  *                251 Colony Ct. Gahanna, Ohio 43230
  379.  */
  380. e1xpand(fnx, afnp)
  381. int (*fnx)();
  382. char *afnp;    /* possible ambiguous file name*/
  383. {
  384.     struct fcb sfcb, *pfcb;
  385.     char *p, *q, i, byteaddr;
  386.     int filecount, m;
  387.     char tbuf[SECSIZ];
  388.     struct {
  389.         char xYxx[UFNSIZE];        /* unambiguous file name */
  390.     } *fp;
  391.     int strcmp();
  392.  
  393.  
  394.     /* build CPM fcb   */
  395.     unspace(afnp);
  396.     if(setfcb(&sfc